/**
 * 成员管理模块
 * 负责处理项目成员的添加、编辑、删除和列表展示功能
 */
const MemberManagement = (function() {
    // 私有变量
    let projectId = null;
    let membersContainer = null;
    let eventsBound = false; // 标记事件是否已绑定
    let state = {
        members: [],
        currentPage: 1,
        totalPages: 1,
        isLoading: false
    };

    // 初始化函数
    function init(projectIdParam, containerId) {
        console.log('开始初始化MemberManagement模块');
        console.log('项目ID参数:', projectIdParam);
        console.log('容器ID参数:', containerId);
        
        // 验证项目ID参数
        if (!projectIdParam) {
            console.error('项目ID参数为空或未定义');
            console.error('初始化成员管理失败：项目ID未提供');
            return;
        }
        
        // 验证容器ID参数
        if (!containerId) {
            console.error('容器ID参数为空或未定义');
            console.error('初始化成员管理失败：容器ID未提供');
            return;
        }
        
        projectId = projectIdParam;
        console.log('设置项目ID:', projectId);
        
        membersContainer = document.getElementById(containerId);
        if (!membersContainer) {
            console.error('成员容器元素未找到，容器ID:', containerId);
            console.error('初始化成员管理失败：无法找到成员容器');
            return;
        }
        
        console.log('成员容器元素已找到:', membersContainer);
        
        // 检查必要的模态框元素是否存在
        const removeMemberModal = document.getElementById('remove-member-modal');
        if (!removeMemberModal) {
            console.error('删除成员模态框未找到 (#remove-member-modal)');
            console.warn('警告：删除成员模态框未找到，删除功能可能无法正常工作');
        } else {
            console.log('删除成员模态框已找到');
        }
        
        const removeMemberForm = document.getElementById('remove-member-form');
        if (!removeMemberForm) {
            console.error('删除成员表单未找到 (#remove-member-form)');
            console.warn('警告：删除成员表单未找到，删除功能可能无法正常工作');
        } else {
            console.log('删除成员表单已找到');
        }
        
        // 绑定事件（如果尚未绑定）
        if (!eventsBound) {
            console.log('事件尚未绑定，开始绑定事件');
            try {
                bindEvents();
                console.log('事件绑定成功');
            } catch (error) {
                console.error('事件绑定失败:', error);
                console.error('初始化成员管理失败：事件绑定出错');
                return;
            }
        } else {
            console.log('事件已绑定，跳过事件绑定');
        }
        
        // 加载成员数据
        console.log('开始加载成员数据');
        try {
            loadMembers();
            console.log('成员数据加载请求已发送');
        } catch (error) {
            console.error('加载成员数据失败:', error);
            console.error('加载成员数据失败，请刷新页面重试');
        }
        
        console.log('MemberManagement模块初始化完成');
    }

    // 绑定事件
    // 绑定成员管理事件
    function bindEvents() {
        // 如果事件已经绑定过，则不再重复绑定
        if (eventsBound) {
            console.log('事件已绑定，跳过重复绑定');
            return;
        }
        
        console.log('开始绑定MemberManagement事件');
        
        // 使用事件委托方式绑定添加成员按钮点击事件
        document.addEventListener('click', (e) => {
            // 查找添加成员按钮
            const addButton = e.target.closest('#add-member-btn, .add-member-btn');
            if (addButton) {
                console.log('添加成员按钮被点击', addButton);
                handleAddMemberClick({ 
                    currentTarget: addButton, 
                    preventDefault: () => e.preventDefault(), 
                    stopPropagation: () => e.stopPropagation() 
                });
                return;
            }
            
            // 查找最近的编辑按钮
            const editButton = e.target.closest('.edit-member, .edit-member-btn');
            if (editButton) {
                console.log('编辑成员按钮被点击', editButton);
                handleEditMemberClick({ 
                    currentTarget: editButton, 
                    preventDefault: () => e.preventDefault(), 
                    stopPropagation: () => e.stopPropagation() 
                });
                return;
            }
            
            // 查找最近的删除按钮
            const deleteButton = e.target.closest('.remove-member, .delete-member-btn');
            if (deleteButton) {
                console.log('删除成员按钮被点击', deleteButton);
                console.log('删除按钮数据属性:', {
                    'data-id': deleteButton.getAttribute('data-id'),
                    'data-user-id': deleteButton.getAttribute('data-user-id'),
                    'data-user-name': deleteButton.getAttribute('data-user-name')
                });
                
                // 验证必要的数据属性是否存在
                const roleId = deleteButton.getAttribute('data-id');
                const userId = deleteButton.getAttribute('data-user-id');
                const userName = deleteButton.getAttribute('data-user-name');
                
                if (!roleId) {
                    console.error('删除按钮缺少data-id属性');
                    showToast('删除成员失败：缺少角色ID', 'error');
                    return;
                }
                
                if (!userId) {
                    console.error('删除按钮缺少data-user-id属性');
                    showToast('删除成员失败：缺少用户ID', 'error');
                    return;
                }
                
                if (!userName) {
                    console.error('删除按钮缺少data-user-name属性');
                    showToast('删除成员失败：缺少用户名', 'error');
                    return;
                }
                
                // 验证projectId是否存在
                if (!projectId) {
                    console.error('项目ID (projectId) 未设置');
                    showToast('删除成员失败：项目ID未设置', 'error');
                    return;
                }
                
                console.log('删除成员按钮数据验证通过');
                
                handleRemoveMemberClick({ 
                    currentTarget: deleteButton, 
                    preventDefault: () => e.preventDefault(), 
                    stopPropagation: () => e.stopPropagation() 
                });
                return;
            }
        });
        
        // 添加成员表单提交事件（使用事件委托）
        document.addEventListener('submit', (e) => {
            if (e.target.id === 'add-member-form') {
                console.log('添加成员表单提交');
                handleAddMemberSubmit(e);
            }
        });
        
        // 编辑成员表单提交事件（使用事件委托）
        document.addEventListener('submit', (e) => {
            if (e.target.id === 'edit-member-form') {
                console.log('编辑成员表单提交');
                handleEditMemberSubmit(e);
            }
        });
        
        // 删除成员表单提交事件（使用事件委托）
        document.addEventListener('submit', (e) => {
            if (e.target.id === 'remove-member-form') {
                console.log('删除成员表单提交');
                
                // 验证表单元素
                const form = e.target;
                if (!form) {
                    console.error('无法获取删除成员表单元素');
                    showToast('删除成员失败：无法获取表单', 'error');
                    e.preventDefault();
                    return;
                }
                
                // 验证表单action是否正确设置
                if (!form.action || form.action === '' || form.action === window.location.href) {
                    console.error('删除成员表单提交URL (action) 未正确设置:', form.action);
                    showToast('删除成员失败：表单提交URL未设置', 'error');
                    e.preventDefault();
                    return;
                }
                
                // 验证URL格式是否正确
                const expectedUrlPattern = /\/project_members\/\d+\/remove$/;
                if (!expectedUrlPattern.test(form.action)) {
                    console.error('删除成员表单提交URL格式不正确:', form.action);
                    showToast('删除成员失败：表单提交URL格式不正确', 'error');
                    e.preventDefault();
                    return;
                }
                
                // 收集表单数据并验证
                const formData = new FormData(form);
                const projectId = formData.get('project_id');
                const userId = formData.get('user_id');
                const roleId = formData.get('role_id');
                
                console.log('删除成员表单数据:', { 
                    projectId, 
                    userId, 
                    roleId, 
                    formAction: form.action 
                });
                
                // 验证必要数据是否存在
                if (!projectId) {
                    console.error('删除成员表单中缺少项目ID (project_id)');
                    showToast('删除成员失败：缺少项目ID', 'error');
                    e.preventDefault();
                    return;
                }
                
                if (!userId && !roleId) {
                    console.error('删除成员表单中缺少用户ID (user_id)或角色ID (role_id)');
                    showToast('删除成员失败：缺少用户/角色ID', 'error');
                    e.preventDefault();
                    return;
                }
                
                console.log('删除成员表单数据验证通过');
                
                handleRemoveMemberSubmit(e);
            }
        });
        
        // 模态框关闭按钮事件（使用事件委托）
        document.addEventListener('click', (e) => {
            // 查找关闭按钮
            const closeButton = e.target.closest('[data-modal-close]');
            if (closeButton) {
                const modalId = closeButton.getAttribute('data-modal-close');
                if (modalId) {
                    closeModal(modalId);
                }
            }
            
            // 添加成员模态框关闭按钮
            if (e.target.closest('#close-add-member-modal')) {
                closeModal('add-member-modal');
            }
            
            // 编辑成员模态框关闭按钮
            if (e.target.closest('#close-edit-member-modal')) {
                closeModal('edit-member-modal');
            }
            
            // 添加成员模态框取消按钮
            if (e.target.closest('#cancel-add-member')) {
                closeModal('add-member-modal');
            }
            
            // 编辑成员模态框取消按钮
            if (e.target.closest('#cancel-edit-member')) {
                closeModal('edit-member-modal');
            }
            
            // 删除成员模态框取消按钮
            if (e.target.closest('#cancel-remove-member')) {
                closeModal('remove-member-modal');
            }
        });
        
        // 点击模态框外部关闭（使用事件委托）
        document.addEventListener('click', (e) => {
            // 检查是否点击了模态框外部
            const modals = ['add-member-modal', 'edit-member-modal', 'remove-member-modal'];
            for (const modalId of modals) {
                const modal = document.getElementById(modalId);
                if (modal && e.target === modal) {
                    closeModal(modalId);
                    break;
                }
            }
        });
        
        // 用户搜索功能（使用事件委托）
        document.addEventListener('input', (e) => {
            if (e.target.id === 'user-search') {
                debounce(handleUserSearch, 300)(e);
            }
        });
        
        // 用户选择下拉框变化事件（使用事件委托）
        document.addEventListener('change', (e) => {
            if (e.target.id === 'user_id') {
                handleUserSelectChange(e);
            }
        });
        
        // 清除用户选择按钮点击事件（使用事件委托）
        document.addEventListener('click', (e) => {
            if (e.target.closest('#clear-user-search')) {
                handleClearUserSearch(e);
            }
        });
        
        // 分页事件（使用事件委托）
        document.addEventListener('click', (e) => {
            const paginationLink = e.target.closest('.members-pagination-link');
            if (paginationLink) {
                e.preventDefault();
                e.stopPropagation();
                
                const page = parseInt(paginationLink.getAttribute('data-page'));
                console.log('分页链接被点击，页码:', page);
                
                if (page && page !== state.currentPage) {
                    loadMembers(page);
                }
            }
        });
        
        // 标记事件已绑定
        eventsBound = true;
        console.log('MemberManagement事件绑定完成');
    }

    // 加载成员数据
    async function loadMembers(page = 1, options = {}) {
        console.log('开始加载成员数据，页码:', page, '选项:', options);
        
        // 检查是否已经有正在进行的请求
        if (state.isLoading) {
            console.log('已有正在进行的成员数据加载请求，跳过重复请求');
            return;
        }
        
        state.isLoading = true;
        
        // 如果是删除操作后的刷新，使用平滑加载
        const isDeleteRefresh = options.isDeleteRefresh || false;
        
        if (isDeleteRefresh) {
            // 对于删除操作，使用覆盖层而非替换内容
            showLoadingOverlay();
        } else {
            // 其他操作使用传统的加载状态
            showLoadingState();
        }
        
        try {
            // 获取当前URL中的其他分页参数
            const urlParams = new URLSearchParams(window.location.search);
            const tasksPage = urlParams.get('tasks_page') || 1;
            const logsPage = urlParams.get('logs_page') || 1;
            
            const response = await fetch(`/projects/${projectId}/members/ajax?members_page=${page}&tasks_page=${tasksPage}&logs_page=${logsPage}`);
            const data = await response.json();
            
            if (data.success) {
                if (isDeleteRefresh) {
                    // 删除操作后使用平滑更新
                    await smoothUpdateMembersList(data.html);
                } else {
                    // 其他操作使用直接更新
                    membersContainer.innerHTML = data.html;
                }
                
                // 更新状态
                state.currentPage = page;
                
                // 重新绑定事件
                bindMemberListEvents();
                bindPaginationEvents();
                
                // 隐藏加载状态
                hideLoadingState();
            } else {
                throw new Error(data.message || '加载成员列表失败');
            }
        } catch (error) {
            console.error('加载成员列表失败:', error);
            showErrorState('加载成员列表失败，请刷新页面重试');
        } finally {
            state.isLoading = false;
        }
    }

    // 绑定成员列表事件
    function bindMemberListEvents() {
        console.log('开始绑定成员列表事件');
        
        // 注意：由于已经在全局事件委托中处理了编辑和删除按钮点击事件，
        // 这里不需要再绑定这些事件，避免重复绑定
        // 保留此函数以保持代码结构，但实际事件处理已移至全局事件委托
        
        console.log('成员列表事件绑定完成（实际事件处理已移至全局事件委托）');
    }

    // 绑定分页事件
    function bindPaginationEvents() {
        console.log('开始绑定分页事件');
        
        // 注意：由于已经在全局事件委托中处理了分页链接点击事件，
        // 这里不需要再绑定这些事件，避免重复绑定
        // 保留此函数以保持代码结构，但实际事件处理已移至全局事件委托
        
        console.log('分页事件绑定完成（实际事件处理已移至全局事件委托）');
    }

    // 处理添加成员按钮点击
    function handleAddMemberClick(e) {
        if (e && e.preventDefault) {
            e.preventDefault();
            e.stopPropagation();
        }
        
        const modal = document.getElementById('add-member-modal');
        if (modal) {
            modal.classList.remove('hidden');
            console.log('添加成员模态框已显示');
            
            // 重置表单
            const form = document.getElementById('add-member-form');
            if (form) {
                form.reset();
                
                // 设置项目ID
                const projectIdField = form.querySelector('input[name="project_id"]');
                if (projectIdField) {
                    projectIdField.value = projectId;
                }
                
                // 设置当前页码
                const currentPage = new URLSearchParams(window.location.search).get('members_page') || 1;
                const membersPageField = form.querySelector('input[name="members_page"]');
                if (membersPageField) {
                    membersPageField.value = currentPage;
                }
                
                // 清空搜索结果
                const searchResults = document.getElementById('user-search-results');
                if (searchResults) {
                    searchResults.innerHTML = '';
                    searchResults.classList.add('hidden');
                }
                
                // 清空搜索框
                const searchInput = document.getElementById('user-search');
                if (searchInput) {
                    searchInput.value = '';
                }
                
                // 重置用户选择下拉框
                const userSelect = document.getElementById('user_id');
                if (userSelect) {
                    userSelect.value = '';
                }
                
                // 重置部门和职位
                const departmentInput = document.getElementById('department');
                const positionInput = document.getElementById('position');
                if (departmentInput) {
                    departmentInput.value = '';
                }
                if (positionInput) {
                    positionInput.value = '';
                }
            }
        } else {
            console.error('未找到添加成员模态框');
        }
    }

    // 处理添加成员表单提交
    async function handleAddMemberSubmit(e) {
        if (e && e.preventDefault) {
            e.preventDefault();
        }
        
        const form = e.target;
        const submitBtn = form.querySelector('button[type="submit"]');
        
        // 验证表单
        const userId = form.user_id.value;
        const role = form.role.value;
        
        if (!userId || !role) {
            showToast('请填写完整信息', 'error');
            return;
        }
        
        // 检查是否已经有正在进行的提交
        if (submitBtn.disabled) {
            console.log('添加成员表单已在提交中，跳过重复提交');
            return;
        }
        
        // 禁用提交按钮
        submitBtn.disabled = true;
        submitBtn.innerHTML = '<i class="fas fa-spinner fa-spin mr-2"></i>提交中...';
        
        try {
            const formData = new FormData(form);
            const response = await fetch(form.action, {
                method: 'POST',
                body: formData,
                headers: {
                    'X-Requested-With': 'XMLHttpRequest'
                }
            });
            
            const data = await response.json();
            
            if (data.success) {
                // 关闭模态框
                closeModal('add-member-modal');
                
                // 显示成功消息
                showToast(data.message || '成员添加成功', 'success');
                
                // 刷新成员列表
                const currentPage = new URLSearchParams(window.location.search).get('members_page') || 1;
                await loadMembers(parseInt(currentPage));
            } else {
                showToast(data.message || '添加成员失败', 'error');
            }
        } catch (error) {
            console.error('添加成员失败:', error);
            showToast('添加成员失败，请重试', 'error');
        } finally {
            // 恢复提交按钮
            submitBtn.disabled = false;
            submitBtn.innerHTML = '添加';
        }
    }

    // 处理编辑成员按钮点击
    function handleEditMemberClick(e) {
        if (e && e.preventDefault) {
            e.preventDefault();
            e.stopPropagation();
        }
        
        const button = e.currentTarget || e;
        const roleId = button.getAttribute('data-id');
        const userId = button.getAttribute('data-user-id');
        const userName = button.getAttribute('data-user-name');
        const role = button.getAttribute('data-role');
        const department = button.getAttribute('data-department') || '';
        const position = button.getAttribute('data-position') || '';
        
        console.log('编辑成员按钮被点击:', { roleId, userId, userName, role, department, position });
        
        const modal = document.getElementById('edit-member-modal');
        if (modal) {
            // 填充表单数据
            const form = document.getElementById('edit-member-form');
            if (form) {
                form.reset();
                
                // 设置隐藏字段
                let roleIdField = form.querySelector('input[name="role_id"]');
                if (!roleIdField) {
                    roleIdField = document.createElement('input');
                    roleIdField.type = 'hidden';
                    roleIdField.name = 'role_id';
                    form.appendChild(roleIdField);
                }
                roleIdField.value = roleId;
                
                let userIdField = form.querySelector('input[name="user_id"]');
                if (!userIdField) {
                    userIdField = document.createElement('input');
                    userIdField.type = 'hidden';
                    userIdField.name = 'user_id';
                    form.appendChild(userIdField);
                }
                userIdField.value = userId;
                
                // 设置用户名显示
                const userNameDisplay = document.getElementById('edit-member-name');
                if (userNameDisplay) {
                    userNameDisplay.textContent = userName;
                    console.log('已设置用户名显示:', userName);
                } else {
                    console.error('未找到编辑成员用户名显示元素');
                }
                
                // 设置角色选择
                const roleSelect = document.getElementById('edit-member-role');
                if (roleSelect) {
                    roleSelect.value = role;
                    console.log('已设置角色选择:', role);
                } else {
                    console.error('未找到编辑成员角色选择元素');
                }
                
                // 设置部门和职位
                const departmentInput = document.getElementById('edit-member-department');
                if (departmentInput) {
                    departmentInput.value = department;
                    console.log('已设置部门:', department);
                } else {
                    console.error('未找到编辑成员部门输入元素');
                }
                
                const positionInput = document.getElementById('edit-member-position');
                if (positionInput) {
                    positionInput.value = position;
                    console.log('已设置职位:', position);
                } else {
                    console.error('未找到编辑成员职位输入元素');
                }
                
                // 设置当前页码
                const currentPage = new URLSearchParams(window.location.search).get('members_page') || 1;
                let membersPageField = form.querySelector('input[name="members_page"]');
                if (!membersPageField) {
                    membersPageField = document.createElement('input');
                    membersPageField.type = 'hidden';
                    membersPageField.name = 'members_page';
                    form.appendChild(membersPageField);
                }
                membersPageField.value = currentPage;
                
                // 设置表单提交URL
                form.action = `/project_members/${roleId}/edit`;
                console.log('已设置表单提交URL:', form.action);
            } else {
                console.error('未找到编辑成员表单');
            }
            
            modal.classList.remove('hidden');
            console.log('编辑成员模态框已显示');
        } else {
            console.error('未找到编辑成员模态框');
        }
    }

    // 处理编辑成员表单提交
    async function handleEditMemberSubmit(e) {
        if (e && e.preventDefault) {
            e.preventDefault();
        }
        
        const form = e.target;
        const submitBtn = form.querySelector('button[type="submit"]');
        
        // 验证表单
        const role = form.role.value;
        
        if (!role) {
            showToast('请选择角色', 'error');
            return;
        }
        
        // 检查是否已经有正在进行的提交
        if (submitBtn.disabled) {
            console.log('编辑成员表单已在提交中，跳过重复提交');
            return;
        }
        
        // 禁用提交按钮
        submitBtn.disabled = true;
        submitBtn.innerHTML = '<i class="fas fa-spinner fa-spin mr-2"></i>保存中...';
        
        try {
            const formData = new FormData(form);
            const response = await fetch(form.action, {
                method: 'POST',
                body: formData,
                headers: {
                    'X-Requested-With': 'XMLHttpRequest'
                }
            });
            
            const data = await response.json();
            
            if (data.success) {
                // 关闭模态框
                closeModal('edit-member-modal');
                
                // 显示成功消息
                showToast(data.message || '成员信息更新成功', 'success');
                
                // 刷新成员列表
                const currentPage = new URLSearchParams(window.location.search).get('members_page') || 1;
                await loadMembers(parseInt(currentPage));
            } else {
                showToast(data.message || '更新成员信息失败', 'error');
            }
        } catch (error) {
            console.error('更新成员信息失败:', error);
            showToast('更新成员信息失败，请重试', 'error');
        } finally {
            // 恢复提交按钮
            submitBtn.disabled = false;
            submitBtn.innerHTML = '保存';
        }
    }

    // 处理删除成员按钮点击
    function handleRemoveMemberClick(e) {
        if (e && e.preventDefault) {
            e.preventDefault();
            e.stopPropagation();
        }
        
        console.log('handleRemoveMemberClick 函数被调用');
        
        const button = e.currentTarget || e;
        if (!button) {
            console.error('无法获取删除按钮元素');
            showToast('删除成员失败：无法获取按钮元素', 'error');
            return;
        }
        
        const roleId = button.getAttribute('data-id');
        const userId = button.getAttribute('data-user-id');
        const userName = button.getAttribute('data-user-name');
        
        console.log('删除成员按钮数据:', { roleId, userId, userName });
        
        // 验证必要的数据是否存在
        if (!roleId) {
            console.error('无法获取角色ID (roleId)');
            showToast('删除成员失败：缺少角色ID', 'error');
            return;
        }
        
        if (!userId) {
            console.error('无法获取用户ID (userId)');
            showToast('删除成员失败：缺少用户ID', 'error');
            return;
        }
        
        if (!userName) {
            console.error('无法获取用户名 (userName)');
            showToast('删除成员失败：缺少用户名', 'error');
            return;
        }
        
        // 验证projectId是否存在
        if (!projectId) {
            console.error('项目ID (projectId) 未设置');
            showToast('删除成员失败：项目ID未设置', 'error');
            return;
        }
        
        console.log('验证通过，开始处理删除成员模态框');
        
        const modal = document.getElementById('remove-member-modal');
        if (!modal) {
            console.error('无法获取删除成员模态框元素');
            showToast('删除成员失败：无法获取模态框', 'error');
            return;
        }
        
        // 填充表单数据
        const form = document.getElementById('remove-member-form');
        if (!form) {
            console.error('无法获取删除成员表单元素');
            showToast('删除成员失败：无法获取表单', 'error');
            return;
        }
        
        console.log('开始设置删除成员表单数据');
        
        // 重置表单
        form.reset();
        
        // 设置用户名显示
        const userNameDisplay = document.getElementById('remove-member-name');
        if (userNameDisplay) {
            userNameDisplay.textContent = userName;
            console.log('设置用户名显示:', userName);
        } else {
            console.error('无法获取用户名显示元素');
        }
        
        // 设置表单提交URL
        const formAction = `/project_members/${roleId}/remove`;
        form.action = formAction;
        console.log('设置表单提交URL:', formAction);
        
        // 添加或更新隐藏字段
        try {
            // 项目ID字段
            const projectIdField = form.querySelector('input[name="project_id"]');
            if (projectIdField) {
                projectIdField.value = projectId;
                console.log('设置项目ID:', projectId);
            } else {
                console.warn('未找到项目ID隐藏字段');
            }
            
            // 用户ID字段
            const userIdField = form.querySelector('input[name="user_id"]');
            if (userIdField) {
                userIdField.value = userId;
                console.log('设置用户ID:', userId);
            } else {
                console.warn('未找到用户ID隐藏字段');
            }
            
            // 角色ID字段 (这是关键，确保后端能正确获取role_id)
            const roleIdField = form.querySelector('input[name="role_id"]');
            if (roleIdField) {
                roleIdField.value = roleId;
                console.log('设置角色ID:', roleId);
            } else {
                console.warn('未找到角色ID隐藏字段');
            }
            
            // 获取当前页码并更新隐藏字段
            const currentPage = new URLSearchParams(window.location.search).get('members_page') || 1;
            const membersPageField = form.querySelector('input[name="members_page"]');
            if (membersPageField) {
                membersPageField.value = currentPage;
                console.log('设置页码:', currentPage);
            } else {
                console.warn('未找到页码隐藏字段');
            }
            
            console.log('表单数据设置完成');
        } catch (error) {
            console.error('设置表单数据时出错:', error);
            showToast('删除成员失败：设置表单数据出错', 'error');
            return;
        }
        
        // 显示模态框
        modal.classList.remove('hidden');
        console.log('删除成员模态框已显示');
    }

    // 处理删除成员表单提交
    async function handleRemoveMemberSubmit(event) {
        event.preventDefault();
        
        console.log('handleRemoveMemberSubmit 函数被调用');
        
        const form = event.target;
        if (!form) {
            console.error('无法获取表单元素');
            showToast('删除成员失败：无法获取表单', 'error');
            return;
        }
        
        console.log('开始处理删除成员表单提交');
        
        const submitBtn = form.querySelector('button[type="submit"]');
        if (!submitBtn) {
            console.error('无法获取提交按钮');
            showToast('删除成员失败：无法获取提交按钮', 'error');
            return;
        }
        
        // 检查是否已经有正在进行的提交
        if (submitBtn.disabled) {
            console.log('删除成员表单已在提交中，跳过重复提交');
            return;
        }
        
        // 禁用提交按钮
        const originalButtonText = submitBtn.innerHTML;
        submitBtn.disabled = true;
        submitBtn.innerHTML = '<i class="fas fa-spinner fa-spin mr-2"></i>删除中...';
        console.log('提交按钮已禁用，原始HTML:', originalButtonText);
        
        const formData = new FormData(form);
        const projectId = formData.get('project_id');
        const memberId = formData.get('member_id');
        const userId = formData.get('user_id');
        const roleId = formData.get('role_id');
        const membersPage = formData.get('members_page');
        
        console.log('表单数据:', { 
            projectId, 
            memberId, 
            userId, 
            roleId, 
            membersPage,
            formAction: form.action 
        });
        
        // 验证必要数据是否存在
        if (!projectId) {
            console.error('表单中缺少项目ID (project_id)');
            showToast('删除成员失败：缺少项目ID', 'error');
            submitBtn.disabled = false;
            submitBtn.innerHTML = originalButtonText;
            return;
        }
        
        if (!userId && !memberId && !roleId) {
            console.error('表单中缺少用户ID (user_id)、成员ID (member_id)或角色ID (role_id)');
            showToast('删除成员失败：缺少用户/成员/角色ID', 'error');
            submitBtn.disabled = false;
            submitBtn.innerHTML = originalButtonText;
            return;
        }
        
        // 验证表单action是否正确设置
        if (!form.action || form.action === '' || form.action === window.location.href) {
            console.error('表单提交URL (action) 未正确设置:', form.action);
            showToast('删除成员失败：表单提交URL未设置', 'error');
            submitBtn.disabled = false;
            submitBtn.innerHTML = originalButtonText;
            return;
        }
        
        // 验证URL格式是否正确
        const expectedUrlPattern = /\/project_members\/\d+\/remove$/;
        if (!expectedUrlPattern.test(form.action)) {
            console.error('表单提交URL格式不正确:', form.action);
            showToast('删除成员失败：表单提交URL格式不正确', 'error');
            submitBtn.disabled = false;
            submitBtn.innerHTML = originalButtonText;
            return;
        }
        
        console.log('表单数据验证通过，准备发送请求');
        
        try {
            // 使用表单的action属性而不是硬编码的URL
            console.log('发送请求到:', form.action);
            const response = await fetch(form.action, {
                method: 'POST',
                body: formData,
                headers: {
                    'X-Requested-With': 'XMLHttpRequest'
                }
            });
            
            console.log('收到服务器响应，状态码:', response.status);
            
            if (!response.ok) {
                // 尝试解析错误响应
                try {
                    const errorData = await response.json();
                    console.error('服务器返回错误:', errorData);
                    throw new Error(errorData.message || errorData.error || `HTTP错误! 状态: ${response.status}`);
                } catch (jsonError) {
                    // 如果无法解析JSON，使用默认错误消息
                    console.error('无法解析错误响应:', jsonError);
                    throw new Error(`HTTP错误! 状态: ${response.status}`);
                }
            }
            
            const data = await response.json();
            console.log('服务器响应数据:', data);
            
            if (data.success) {
                // 先显示成功消息，避免被后续操作覆盖
                if (data.message) {
                    showToast(data.message, 'success');
                } else {
                    showToast('成员移除成功', 'success');
                }
                
                // 关闭模态框
                const modal = document.getElementById('remove-member-modal');
                if (modal) {
                    modal.classList.add('hidden');
                    console.log('删除成员模态框已关闭');
                } else {
                    console.warn('无法获取删除成员模态框，无法关闭');
                }
                
                // 刷新成员列表
                const currentPage = new URLSearchParams(window.location.search).get('members_page') || 1;
                console.log('准备刷新成员列表，页码:', currentPage);
                
                if (typeof loadMembers === 'function') {
                    try {
                        await loadMembers(parseInt(currentPage), { isDeleteRefresh: true });
                        console.log('成员列表已刷新');
                    } catch (loadError) {
                        console.error('刷新成员列表失败:', loadError);
                        // 即使刷新失败，也不显示错误消息，因为删除已经成功
                        // 可以选择刷新整个页面作为后备方案
                        if (confirm('成员已删除，但刷新列表失败。是否刷新页面？')) {
                            window.location.reload();
                        }
                    }
                } else {
                    console.warn('loadMembers 函数不存在，无法刷新成员列表');
                    // 如果loadMembers函数不存在，刷新整个页面
                    window.location.reload();
                }
            } else {
                // 显示错误提示
                console.error('服务器返回操作失败:', data);
                showToast(data.message || '移除成员失败', 'error');
            }
        } catch (error) {
            console.error('移除成员失败:', error);
            
            // 显示错误消息
            if (error.message) {
                showToast(`删除成员失败: ${error.message}`, 'error');
            } else {
                showToast('删除成员失败，请稍后重试', 'error');
            }
        } finally {
            // 恢复提交按钮
            if (submitBtn) {
                submitBtn.disabled = false;
                submitBtn.innerHTML = originalButtonText;
                console.log('提交按钮状态已恢复');
            }
        }
    }

    // 处理用户搜索
    async function handleUserSearch(e) {
        const searchTerm = e.target.value.trim();
        const searchResults = document.getElementById('user-search-results');
        
        if (!searchTerm) {
            searchResults.innerHTML = '';
            searchResults.classList.add('hidden');
            return;
        }
        
        try {
            // 修复API路径，从/users/search改为/system/users/search
            const response = await fetch(`/system/users/search?q=${encodeURIComponent(searchTerm)}`);
            const data = await response.json();
            
            // 修复返回数据格式，从data.users改为data.results
            if (data.success && data.results.length > 0) {
                // 渲染搜索结果
                searchResults.innerHTML = data.results.map(user => `
                    <div class="user-search-result-item px-4 py-2 hover:bg-gray-100 cursor-pointer" data-user-id="${user.id}" data-user-name="${user.name}" data-department="${user.department || ''}" data-position="${user.position || ''}">
                        <div class="font-medium">${user.name}</div>
                        <div class="text-sm text-gray-500">${user.department || ''} - ${user.position || ''}</div>
                    </div>
                `).join('');
                
                searchResults.classList.remove('hidden');
                
                // 绑定搜索结果点击事件
                searchResults.querySelectorAll('.user-search-result-item').forEach(item => {
                    item.addEventListener('click', function() {
                        const userId = this.getAttribute('data-user-id');
                        const userName = this.getAttribute('data-user-name');
                        const userDepartment = this.getAttribute('data-department');
                        const userPosition = this.getAttribute('data-position');
                        
                        // 填充表单
                        document.getElementById('user_id').value = userId;
                        
                        // 填充部门和职位
                        const departmentInput = document.getElementById('department');
                        const positionInput = document.getElementById('position');
                        if (departmentInput) {
                            departmentInput.value = userDepartment;
                        }
                        if (positionInput) {
                            positionInput.value = userPosition;
                        }
                        
                        // 在搜索框中显示用户名称，而不是清空
                    e.target.value = userName;
                    
                    // 添加视觉反馈，表示已选择用户
                    e.target.classList.add('bg-green-50', 'border-green-300');
                    e.target.setAttribute('readonly', true);
                    
                    // 清空搜索结果
                    searchResults.innerHTML = '';
                    searchResults.classList.add('hidden');
                    
                    // 显示清除按钮
                    const clearButton = document.getElementById('clear-user-search');
                    clearButton.classList.remove('hidden');
                    });
                });
            } else {
                searchResults.innerHTML = '<div class="px-4 py-2 text-gray-500">未找到匹配的用户</div>';
                searchResults.classList.remove('hidden');
            }
        } catch (error) {
            console.error('搜索用户失败:', error);
            searchResults.innerHTML = '<div class="px-4 py-2 text-red-500">搜索失败，请重试</div>';
            searchResults.classList.remove('hidden');
        }
    }

    // 处理用户选择变化
    function handleUserSelectChange(e) {
        const userId = e.target.value;
        const departmentInput = document.getElementById('department');
        const positionInput = document.getElementById('position');
        
        if (userId && departmentInput && positionInput) {
            // 获取用户信息并自动填充部门和职位
            fetch(`/users/${userId}`)
                .then(response => response.json())
                .then(data => {
                    if (data.success) {
                        departmentInput.value = data.user.department || '';
                        positionInput.value = data.user.position || '';
                    }
                })
                .catch(error => {
                    console.error('获取用户信息失败:', error);
                });
        }
    }

    // 处理清除用户选择
    function handleClearUserSearch(e) {
        e.preventDefault();
        e.stopPropagation();
        
        const searchInput = document.getElementById('user-search');
        const userSelect = document.getElementById('user_id');
        const departmentInput = document.getElementById('department');
        const positionInput = document.getElementById('position');
        const clearButton = document.getElementById('clear-user-search');
        
        // 重置搜索框
        searchInput.value = '';
        searchInput.classList.remove('bg-green-50', 'border-green-300');
        searchInput.removeAttribute('readonly');
        
        // 重置用户选择
        userSelect.value = '';
        
        // 清空部门和职位
        departmentInput.value = '';
        positionInput.value = '';
        
        // 隐藏清除按钮
        clearButton.classList.add('hidden');
        
        // 聚焦到搜索框，方便用户重新输入
        searchInput.focus();
    }

    // 关闭模态框
    function closeModal(modalId) {
        const modal = document.getElementById(modalId);
        if (modal) {
            modal.classList.add('hidden');
            
            // 如果关闭的是添加成员模态框，重置表单和搜索框状态
            if (modalId === 'add-member-modal') {
                const form = document.getElementById('add-member-form');
                if (form) {
                    form.reset();
                }
                
                const searchInput = document.getElementById('user-search');
                const clearButton = document.getElementById('clear-user-search');
                
                if (searchInput) {
                    searchInput.value = '';
                    searchInput.classList.remove('bg-green-50', 'border-green-300');
                    searchInput.removeAttribute('readonly');
                }
                
                if (clearButton) {
                    clearButton.classList.add('hidden');
                }
            }
        }
    }

    // 显示加载状态
    function showLoadingState() {
        if (membersContainer) {
            membersContainer.innerHTML = '<div class="text-center py-4"><i class="fas fa-spinner fa-spin text-2xl text-primary"></i><p class="mt-2 text-gray-600">加载中...</p></div>';
        }
    }

    // 显示加载覆盖层
    function showLoadingOverlay() {
        if (!membersContainer) return;
        
        // 检查是否已存在覆盖层
        let overlay = document.getElementById('members-loading-overlay');
        if (!overlay) {
            // 创建覆盖层元素
            overlay = document.createElement('div');
            overlay.id = 'members-loading-overlay';
            overlay.className = 'absolute inset-0 bg-white bg-opacity-75 flex items-center justify-center z-10 transition-opacity duration-300 opacity-0';
            overlay.innerHTML = '<div class="text-center"><i class="fas fa-spinner fa-spin text-3xl text-primary"></i><p class="mt-2 text-gray-600">处理中...</p></div>';
            
            // 确保容器有相对定位
            if (getComputedStyle(membersContainer).position === 'static') {
                membersContainer.style.position = 'relative';
            }
            
            // 添加覆盖层到容器
            membersContainer.appendChild(overlay);
            
            // 触发淡入效果
            setTimeout(() => {
                overlay.classList.remove('opacity-0');
                overlay.classList.add('opacity-100');
            }, 10);
        }
    }

    // 隐藏加载状态
    function hideLoadingState() {
        // 加载完成后会自动替换为实际内容，不需要特别处理
    }

    // 显示错误状态
    function showErrorState(message) {
        if (membersContainer) {
            membersContainer.innerHTML = `<div class="text-center py-4 text-red-500"><i class="fas fa-exclamation-circle text-2xl"></i><p class="mt-2">${message}</p></div>`;
        }
    }

    // 显示提示消息
    function showToast(message, type = 'success') {
        const messageElement = document.getElementById(type + 'ToastMessage');
        const toastElement = document.getElementById(type + 'Toast');
        if (messageElement && toastElement) {
            messageElement.textContent = message;
            toastElement.classList.remove('translate-x-full');
            
            // 3秒后自动隐藏
            setTimeout(() => {
                hideToast(type + 'Toast');
            }, 3000);
        }
    }
    
    // 隐藏提示消息
    function hideToast(toastId) {
        const toastElement = document.getElementById(toastId);
        if (toastElement) {
            toastElement.classList.add('translate-x-full');
        }
    }
    
    // 显示成功提示
    function showSuccessToast(message) {
        showToast(message, 'success');
    }

    // 防抖函数
    function debounce(func, wait) {
        let timeout;
        return function(...args) {
            const context = this;
            clearTimeout(timeout);
            timeout = setTimeout(() => func.apply(context, args), wait);
        };
    }

    // 平滑更新成员列表
    async function smoothUpdateMembersList(newHtml) {
        if (!membersContainer) return;
        
        console.log('开始平滑更新成员列表');
        
        // 创建临时元素来解析新HTML
        const tempDiv = document.createElement('div');
        tempDiv.innerHTML = newHtml;
        
        // 获取新表格和分页元素
        const newTable = tempDiv.querySelector('#members-table');
        const newPagination = tempDiv.querySelector('#members-pagination');
        
        console.log('新元素查找结果:', { 
            newTable: !!newTable, 
            newPagination: !!newPagination 
        });
        
        // 获取当前表格和分页元素
        const currentTable = membersContainer.querySelector('#members-table');
        const currentPagination = membersContainer.querySelector('#members-pagination');
        
        console.log('当前元素查找结果:', { 
            currentTable: !!currentTable, 
            currentPagination: !!currentPagination 
        });
        
        // 如果找不到元素，直接替换整个容器内容
        if (!newTable || !currentTable) {
            console.warn('无法找到表格元素，直接替换整个容器内容');
            membersContainer.innerHTML = newHtml;
            
            // 移除加载覆盖层
            const overlay = document.getElementById('members-loading-overlay');
            if (overlay) {
                overlay.classList.remove('opacity-100');
                overlay.classList.add('opacity-0');
                
                // 等待淡出效果完成后移除
                setTimeout(() => {
                    if (overlay.parentNode) {
                        overlay.parentNode.removeChild(overlay);
                    }
                }, 300);
            }
            return;
        }
        
        // 添加淡出效果
        currentTable.classList.add('transition-opacity', 'duration-300');
        currentTable.classList.add('opacity-50');
        
        // 等待淡出效果完成
        await new Promise(resolve => setTimeout(resolve, 150));
        
        // 更新表格
        if (currentTable && newTable) {
            // 创建新表格的副本
            const newTableClone = newTable.cloneNode(true);
            newTableClone.classList.add('opacity-0');
            newTableClone.classList.add('transition-opacity');
            newTableClone.classList.add('duration-300');
            
            // 替换表格
            currentTable.parentNode.replaceChild(newTableClone, currentTable);
            
            // 触发淡入效果
            setTimeout(() => {
                newTableClone.classList.remove('opacity-0');
                newTableClone.classList.add('opacity-100');
            }, 10);
        }
        
        // 更新分页
        if (currentPagination && newPagination) {
            currentPagination.innerHTML = newPagination.innerHTML;
        }
        
        // 移除加载覆盖层
        const overlay = document.getElementById('members-loading-overlay');
        if (overlay) {
            overlay.classList.remove('opacity-100');
            overlay.classList.add('opacity-0');
            
            // 等待淡出效果完成后移除
            setTimeout(() => {
                if (overlay.parentNode) {
                    overlay.parentNode.removeChild(overlay);
                }
            }, 300);
        }
        
        console.log('成员列表平滑更新完成');
    }

    // 公共API
    return {
        init: init,
        loadMembers: loadMembers,
        getState: () => state
    };
})();

// 将模块添加到全局作用域，以便在模板中调用
window.MemberManagement = MemberManagement;
